// let arr = [];
// //匿名函数作为参数传给filter(),这个匿名函数就是一个回调函数
// arr.filter(function (item) {
//     return item == 2
// })
// function foo() {

// }
// foo(a, b)

/**
 * 自定义filter筛选方法
 * @param {*} arr数组
 * @param {*} callback 回调函数 返回true或false
 * @returns 筛选后的新数组
 */


function myFilter(arr, callback) {
    let newArr = []
    for (let i = 0; i < arr.length; i++) {
        if (callback(arr[i], i, arr)) {
            newArr.push(arr[i]);
        }
    }
    return newArr;
}

let myArr = [17, 4, 25, 27, 31, 12];

let arr = myFilter(myArr, function (item) {
    return item > 10
})
console.log(arr);

/**
 * 定义一个函数筛选满足条件的个数
 * @param 数组
 * @param callback
 * @returns 满足条件的个数
 */

// function myCount(arr, callback) {
//     let count = 0;//记录满足条件的个数
//     for (let i = 0; i < arr.length; i++) {
//         if (callback(arr[i])) {
//             count++;
//         }
//     }
//     return count;
// }
//[ 31, 8, 23, 27, 25, 17 ]  
// let arr1 = [31, 8, 23, 27, 25, 17], arr2 = [17, 4, 25, 27, 31, 12];
// let c = myCount(arr1, function (item) {
//     return arr2.includes(item)
// })
// console.log(c);


// function foo(a, b) {
//     return a + b
// }

// let foo = a => a + 10

// let num = foo(10);
// console.log(num);

// 1.比普通函数更简洁
// 2.当参数只有一个时，可以省略圆括号
// 3.函数体只有一句时，可以把花括号省略
// 4.如果函数体里只有一句return,可以把return关键字省略
// 5.箭头函数没有自己的this指向，没有arguments


// arr.sort((a, b) => a - b);
// arr.sort(function (a, b) {
//     return a - b
// })


//作用域：变量生效的范围
// 1.全局作用域
// 2.块级作用域
// 3.函数作用域


//let和const 没有变量提升，所以在声明前访问会报错，这一部分我们成为暂时性死区
// let n = 10;

// console.log(i);
// for (let i = 0; i < 4; i++) {
//     console.log(i);
// }
// console.log(i);


// let a = 10;
// function fn() {
//     // let b = 20;
//     console.log(b);
// }

// fn();
// var b = 30;

// function fn1() {
//     console.log(a);
//     var a = 10;
// }
// fn1()
// console.log(a);


// console.log(fn);
// var fn = 10;
// function fn() {
//     console.log(111);
// }
// // fn()
// console.log(fn);
//==========
// function fn() {
//     console.log(111);
// }
// var fn;
// console.log(fn);
// fn=10;
// console.log(fn);


// num=10;
// var num;
// console.log(num);//10

// var foo = 1;
// function bar(){
//     console.log(foo);
//     if(!foo){
//         var foo = 10;
//     }
//     console.log(foo);
// }
// bar();

// if (true) {
//     var num = 10;
// }
// console.log(num);


// 1.变量在查找时，先看自己有没有，如果没有再向上查找，这样的查找就是链式查找，形成作用域链。
// 2.在js中存在声明式函数的函数提升和var的变量提升，函数是js的一等功民，先提升到当前作用域的最顶端，再进行变量提升。
// 3.变量提升时需注意，var没有块级作用域，它提升时提升到当前函数作用域或者全局作用域的最顶端
// 4.var提升时，只提升变量不提升值
